@redwoodjs/agent-ci 0.6.0 → 0.7.1

package/dist/cli.js

@@ -130,9 +130,11 @@ async function run() {
                 pauseOnFailure,
                 noMatrix,
             });
-            printSummary(results);
+            if (results.length > 0) {
+                printSummary(results);
+            }
             postCommitStatus(results, sha);
-            const anyFailed = results.some((r) => !r.succeeded);
+            const anyFailed = results.length === 0 || results.some((r) => !r.succeeded);
             process.exit(anyFailed ? 1 : 0);
         }
         if (!workflow) {
@@ -163,9 +165,11 @@ async function run() {
             pauseOnFailure,
             noMatrix,
         });
-        printSummary(results);
+        if (results.length > 0) {
+            printSummary(results);
+        }
         postCommitStatus(results, sha);
-        if (results.some((r) => !r.succeeded)) {
+        if (results.length === 0 || results.some((r) => !r.succeeded)) {
             process.exit(1);
         }
         process.exit(0);
@@ -241,6 +245,9 @@ async function run() {
 // One workflow = --all with a single entry.
 async function runWorkflows(options) {
     const { workflowPaths, sha, pauseOnFailure, noMatrix = false } = options;
+    // Suppress EventEmitter MaxListenersExceeded warnings when running many
+    // parallel jobs (each job adds SIGINT/SIGTERM listeners).
+    process.setMaxListeners(0);
     // Create the run state store — single source of truth for all progress
     const runId = `run-${Date.now()}`;
     const storeFilePath = path.join(getWorkingDirectory(), "runs", runId, "run-state.json");
@@ -318,6 +325,15 @@ async function runWorkflows(options) {
             }
         }, 80);
     }
+    // Top-level signal handler: exit the process after per-job handlers have
+    // cleaned up their containers. All listeners fire synchronously in
+    // registration order, so we defer the exit to let per-job handlers
+    // (registered later in local-job.ts) run first.
+    const exitOnSignal = () => {
+        setTimeout(() => process.exit(1), 0);
+    };
+    process.on("SIGINT", exitOnSignal);
+    process.on("SIGTERM", exitOnSignal);
     try {
         const allResults = [];
         if (workflowPaths.length === 1) {
@@ -343,6 +359,11 @@ async function runWorkflows(options) {
             catch { }
             const warmModulesDir = path.resolve(getWorkingDirectory(), "cache", "warm-modules", repoSlug, lockfileHash);
             const warm = isWarmNodeModules(warmModulesDir);
+            // Pre-allocate unique run numbers so parallel workflows don't collide.
+            // Each workflow gets its own baseRunNum (e.g. 306, 307, 308) so their
+            // job suffixes (-j1, -j2, -j3) never produce duplicate container names.
+            const baseRunNum = getNextLogNum("agent-ci");
+            const runNums = workflowPaths.map((_, i) => baseRunNum + i);
             if (!warm && workflowPaths.length > 1) {
                 // Cold cache — run first workflow serially to populate warm modules,
                 // then launch the rest in parallel.
@@ -352,11 +373,17 @@ async function runWorkflows(options) {
                     pauseOnFailure,
                     noMatrix,
                     store,
+                    baseRunNum: runNums[0],
                 });
                 allResults.push(...firstResults);
-                const settled = await Promise.allSettled(workflowPaths
-                    .slice(1)
-                    .map((wf) => handleWorkflow({ workflowPath: wf, sha, pauseOnFailure, noMatrix, store })));
+                const settled = await Promise.allSettled(workflowPaths.slice(1).map((wf, i) => handleWorkflow({
+                    workflowPath: wf,
+                    sha,
+                    pauseOnFailure,
+                    noMatrix,
+                    store,
+                    baseRunNum: runNums[i + 1],
+                })));
                 for (const s of settled) {
                     if (s.status === "fulfilled") {
                         allResults.push(...s.value);
@@ -367,7 +394,14 @@ async function runWorkflows(options) {
                 }
             }
             else {
-                const settled = await Promise.allSettled(workflowPaths.map((wf) => handleWorkflow({ workflowPath: wf, sha, pauseOnFailure, noMatrix, store })));
+                const settled = await Promise.allSettled(workflowPaths.map((wf, i) => handleWorkflow({
+                    workflowPath: wf,
+                    sha,
+                    pauseOnFailure,
+                    noMatrix,
+                    store,
+                    baseRunNum: runNums[i],
+                })));
                 for (const s of settled) {
                     if (s.status === "fulfilled") {
                         allResults.push(...s.value);
@@ -382,6 +416,8 @@ async function runWorkflows(options) {
         return allResults;
     }
     finally {
+        process.removeListener("SIGINT", exitOnSignal);
+        process.removeListener("SIGTERM", exitOnSignal);
         if (renderInterval) {
             clearInterval(renderInterval);
         }
@@ -492,7 +528,7 @@ async function handleWorkflow(options) {
         const warmModulesDir = path.resolve(getWorkingDirectory(), "cache", "warm-modules", repoSlug, lockfileHash);
         let warm = isWarmNodeModules(warmModulesDir);
         // Naming convention: agent-ci-<N>[-j<idx>][-m<shardIdx>]
-        const baseRunNum = getNextLogNum("agent-ci");
+        const baseRunNum = options.baseRunNum ?? getNextLogNum("agent-ci");
         let globalIdx = 0;
         const buildJob = (ej) => {
             const secrets = loadMachineSecrets(repoRoot);
@@ -699,8 +735,8 @@ async function handleWorkflow(options) {
         return allResults;
     }
     catch (error) {
-        console.error(`[Agent CI] Failed to trigger run: ${error.message}`);
-        return [];
+        console.error(`[Agent CI] Failed to run workflow ${path.basename(workflowPath)}: ${error.message}`);
+        throw error;
     }
 }
 // ─── Utilities ────────────────────────────────────────────────────────────────

package/dist/docker/container-config.js

@@ -11,6 +11,7 @@ export function buildContainerEnv(opts) {
         `GITHUB_API_URL=${dockerApiUrl}`,
         `GITHUB_SERVER_URL=${repoUrl}`,
         `GITHUB_REPOSITORY=${githubRepo}`,
+        `AGENT_CI_LOCAL=true`,
         `AGENT_CI_LOCAL_SYNC=true`,
         `AGENT_CI_HEAD_SHA=${headSha || "HEAD"}`,
         `AGENT_CI_DTU_HOST=${dtuHost}`,
@@ -44,10 +45,10 @@ export function buildContainerBinds(opts) {
         ...(signalsDir ? [`${h(signalsDir)}:/tmp/agent-ci-signals`] : []),
         `${h(diagDir)}:/home/runner/_diag`,
         `${h(toolCacheDir)}:/opt/hostedtoolcache`,
-        // Package manager caches (persist across runs)
-        `${h(pnpmStoreDir)}:/home/runner/_work/.pnpm-store`,
-        `${h(npmCacheDir)}:/home/runner/.npm`,
-        `${h(bunCacheDir)}:/home/runner/.bun/install/cache`,
+        // Package manager caches (persist across runs, only for detected PM)
+        ...(pnpmStoreDir ? [`${h(pnpmStoreDir)}:/home/runner/_work/.pnpm-store`] : []),
+        ...(npmCacheDir ? [`${h(npmCacheDir)}:/home/runner/.npm`] : []),
+        ...(bunCacheDir ? [`${h(bunCacheDir)}:/home/runner/.bun/install/cache`] : []),
         `${h(playwrightCacheDir)}:/home/runner/.cache/ms-playwright`,
         // Warm node_modules: mounted outside the workspace so actions/checkout can
         // delete the symlink without EBUSY. A symlink in the entrypoint points

package/dist/docker/container-config.test.js

@@ -1,4 +1,4 @@
-import { describe, it, expect, afterEach, vi } from "vitest";
+import { describe, it, expect, afterEach, beforeEach, vi } from "vitest";
 import fs from "node:fs";
 afterEach(() => {
     vi.restoreAllMocks();
@@ -19,6 +19,7 @@ describe("buildContainerEnv", () => {
         });
         expect(env).toContain("RUNNER_NAME=runner-1");
         expect(env).toContain("GITHUB_REPOSITORY=org/repo");
+        expect(env).toContain("AGENT_CI_LOCAL=true");
         expect(env).toContain("AGENT_CI_HEAD_SHA=abc123");
         expect(env).toContain("FORCE_COLOR=1");
         // Should NOT include root-mode vars for standard container
@@ -41,7 +42,7 @@ describe("buildContainerEnv", () => {
 });
 // ── buildContainerBinds ───────────────────────────────────────────────────────
 describe("buildContainerBinds", () => {
-    it("builds standard bind mounts", async () => {
+    it("builds standard bind mounts with all PM caches", async () => {
         const { buildContainerBinds } = await import("./container-config.js");
         const binds = buildContainerBinds({
             hostWorkDir: "/tmp/work",
@@ -60,9 +61,46 @@ describe("buildContainerBinds", () => {
         expect(binds).toContain("/var/run/docker.sock:/var/run/docker.sock");
         expect(binds).toContain("/tmp/shims:/tmp/agent-ci-shims");
         expect(binds).toContain("/tmp/warm:/tmp/warm-modules");
+        expect(binds).toContain("/tmp/pnpm:/home/runner/_work/.pnpm-store");
+        expect(binds).toContain("/tmp/npm:/home/runner/.npm");
+        expect(binds).toContain("/tmp/bun:/home/runner/.bun/install/cache");
         // Standard mode should NOT include runner home bind (but _work bind is expected)
         expect(binds.some((b) => b.endsWith(":/home/runner"))).toBe(false);
     });
+    it("omits PM bind mounts when cache dirs are not provided", async () => {
+        const { buildContainerBinds } = await import("./container-config.js");
+        const binds = buildContainerBinds({
+            hostWorkDir: "/tmp/work",
+            shimsDir: "/tmp/shims",
+            diagDir: "/tmp/diag",
+            toolCacheDir: "/tmp/toolcache",
+            playwrightCacheDir: "/tmp/playwright",
+            warmModulesDir: "/tmp/warm",
+            hostRunnerDir: "/tmp/runner",
+            useDirectContainer: false,
+        });
+        expect(binds).toContain("/tmp/work:/home/runner/_work");
+        expect(binds.some((b) => b.includes(".pnpm-store"))).toBe(false);
+        expect(binds.some((b) => b.includes("/.npm"))).toBe(false);
+        expect(binds.some((b) => b.includes(".bun"))).toBe(false);
+    });
+    it("includes only the npm bind mount when only npmCacheDir is provided", async () => {
+        const { buildContainerBinds } = await import("./container-config.js");
+        const binds = buildContainerBinds({
+            hostWorkDir: "/tmp/work",
+            shimsDir: "/tmp/shims",
+            diagDir: "/tmp/diag",
+            toolCacheDir: "/tmp/toolcache",
+            npmCacheDir: "/tmp/npm",
+            playwrightCacheDir: "/tmp/playwright",
+            warmModulesDir: "/tmp/warm",
+            hostRunnerDir: "/tmp/runner",
+            useDirectContainer: false,
+        });
+        expect(binds).toContain("/tmp/npm:/home/runner/.npm");
+        expect(binds.some((b) => b.includes(".pnpm-store"))).toBe(false);
+        expect(binds.some((b) => b.includes(".bun"))).toBe(false);
+    });
     it("includes runner bind mount for direct container", async () => {
         const { buildContainerBinds } = await import("./container-config.js");
         const binds = buildContainerBinds({
@@ -146,6 +184,10 @@ describe("resolveDockerApiUrl", () => {
 });
 describe("resolveDtuHost", () => {
     const originalBridgeGateway = process.env.AGENT_CI_DOCKER_BRIDGE_GATEWAY;
+    const originalDtuHost = process.env.AGENT_CI_DTU_HOST;
+    beforeEach(() => {
+        delete process.env.AGENT_CI_DTU_HOST;
+    });
     afterEach(() => {
         if (originalBridgeGateway === undefined) {
             delete process.env.AGENT_CI_DOCKER_BRIDGE_GATEWAY;
@@ -153,8 +195,15 @@ describe("resolveDtuHost", () => {
         else {
             process.env.AGENT_CI_DOCKER_BRIDGE_GATEWAY = originalBridgeGateway;
         }
+        if (originalDtuHost === undefined) {
+            delete process.env.AGENT_CI_DTU_HOST;
+        }
+        else {
+            process.env.AGENT_CI_DTU_HOST = originalDtuHost;
+        }
     });
     it("uses host alias when available outside Docker", async () => {
+        delete process.env.AGENT_CI_DTU_HOST;
         const { resolveDtuHost } = await import("./container-config.js");
         const originalExistsSync = fs.existsSync;
         vi.spyOn(fs, "existsSync").mockImplementation((filePath) => {
@@ -166,6 +215,7 @@ describe("resolveDtuHost", () => {
         await expect(resolveDtuHost()).resolves.toBe("host.docker.internal");
     });
     it("uses configured bridge gateway outside Docker when provided", async () => {
+        delete process.env.AGENT_CI_DTU_HOST;
         const { resolveDtuHost } = await import("./container-config.js");
         const originalExistsSync = fs.existsSync;
         vi.spyOn(fs, "existsSync").mockImplementation((filePath) => {
@@ -178,6 +228,7 @@ describe("resolveDtuHost", () => {
         await expect(resolveDtuHost()).resolves.toBe("10.10.0.1");
     });
     it("uses host alias outside Docker when no gateway override is configured", async () => {
+        delete process.env.AGENT_CI_DTU_HOST;
         const { resolveDtuHost } = await import("./container-config.js");
         const originalExistsSync = fs.existsSync;
         vi.spyOn(fs, "existsSync").mockImplementation((filePath) => {

package/dist/docker/repro-126.test.js

@@ -0,0 +1,72 @@
+/**
+ * Reproduction for https://github.com/redwoodjs/agent-ci/issues/126
+ *
+ * When running inside Docker (via agent-ci), AGENT_CI_DTU_HOST is set in the
+ * container environment. The resolveDtuHost tests delete it, but this test
+ * verifies the mock and env var interaction actually works in that scenario.
+ */
+import { describe, it, expect, afterEach, beforeEach, vi } from "vitest";
+import fs from "node:fs";
+afterEach(() => {
+    vi.restoreAllMocks();
+});
+describe("issue-126 reproduction: resolveDtuHost inside Docker", () => {
+    const originalBridgeGateway = process.env.AGENT_CI_DOCKER_BRIDGE_GATEWAY;
+    const originalDtuHost = process.env.AGENT_CI_DTU_HOST;
+    beforeEach(() => {
+        delete process.env.AGENT_CI_DTU_HOST;
+    });
+    afterEach(() => {
+        if (originalBridgeGateway === undefined) {
+            delete process.env.AGENT_CI_DOCKER_BRIDGE_GATEWAY;
+        }
+        else {
+            process.env.AGENT_CI_DOCKER_BRIDGE_GATEWAY = originalBridgeGateway;
+        }
+        if (originalDtuHost === undefined) {
+            delete process.env.AGENT_CI_DTU_HOST;
+        }
+        else {
+            process.env.AGENT_CI_DTU_HOST = originalDtuHost;
+        }
+    });
+    it("reports environment state", async () => {
+        console.log("--- issue-126 repro diagnostics ---");
+        console.log("/.dockerenv exists:", fs.existsSync("/.dockerenv"));
+        console.log("AGENT_CI_DTU_HOST:", process.env.AGENT_CI_DTU_HOST ?? "(unset)");
+        console.log("AGENT_CI_DOCKER_BRIDGE_GATEWAY:", process.env.AGENT_CI_DOCKER_BRIDGE_GATEWAY ?? "(unset)");
+        expect(true).toBe(true);
+    });
+    it("mock fs.existsSync intercepts /.dockerenv check", async () => {
+        const realResult = fs.existsSync("/.dockerenv");
+        console.log("Real fs.existsSync('/.dockerenv'):", realResult);
+        const originalExistsSync = fs.existsSync;
+        vi.spyOn(fs, "existsSync").mockImplementation((filePath) => {
+            if (filePath === "/.dockerenv") {
+                return false;
+            }
+            return originalExistsSync(filePath);
+        });
+        const mockedResult = fs.existsSync("/.dockerenv");
+        console.log("Mocked fs.existsSync('/.dockerenv'):", mockedResult);
+        expect(mockedResult).toBe(false);
+    });
+    it("resolveDtuHost uses bridge gateway when mock is active (the failing test)", async () => {
+        // Simulate agent-ci Docker env: AGENT_CI_DTU_HOST was set but we deleted it
+        delete process.env.AGENT_CI_DTU_HOST;
+        const { resolveDtuHost } = await import("./container-config.js");
+        const originalExistsSync = fs.existsSync;
+        vi.spyOn(fs, "existsSync").mockImplementation((filePath) => {
+            if (filePath === "/.dockerenv") {
+                return false;
+            }
+            return originalExistsSync(filePath);
+        });
+        process.env.AGENT_CI_DOCKER_BRIDGE_GATEWAY = "10.10.0.1";
+        // This is the assertion that was failing: expected '10.10.0.1' but got 'host.docker.internal'
+        const result = await resolveDtuHost();
+        console.log("resolveDtuHost() returned:", result);
+        console.log("Expected: 10.10.0.1");
+        expect(result).toBe("10.10.0.1");
+    });
+});

package/dist/docker/shutdown.js

@@ -43,14 +43,31 @@ export function killRunnerContainers(runnerName) {
 }
 /**
  * Remove orphaned Docker resources left behind by previous runs:
- *   1. `agent-ci-net-*` networks with no connected containers
- *   2. Dangling volumes (anonymous volumes from service containers like MySQL)
+ *   1. Stopped `agent-ci-*` containers (runners + sidecars)
+ *   2. `agent-ci-net-*` networks with no connected containers
+ *   3. Dangling volumes (anonymous volumes from service containers like MySQL)
+ *
+ * Stopped containers must be removed first so their network references are
+ * released, allowing the network prune in step 2 to reclaim address pool capacity.
  *
  * Call this proactively before creating new resources to prevent Docker from
  * exhausting its address pool ("all predefined address pools have been fully subnetted").
  */
 export function pruneOrphanedDockerResources() {
-    // 1. Remove orphaned agent-ci-net-* networks
+    // 1. Remove stopped agent-ci-* containers (runners + sidecars) so their
+    //    network references are released before we try to prune networks.
+    try {
+        const stoppedIds = execSync(`docker ps -aq --filter "name=agent-ci-" --filter "status=exited"`, { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+        if (stoppedIds) {
+            execSync(`docker rm -f ${stoppedIds.split("\n").join(" ")}`, {
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+        }
+    }
+    catch {
+        // Docker not reachable or no stopped containers — skip
+    }
+    // 2. Remove orphaned agent-ci-net-* networks
     try {
         const nets = execSync(`docker network ls -q --filter "name=agent-ci-net-"`, {
             encoding: "utf8",
@@ -74,7 +91,7 @@ export function pruneOrphanedDockerResources() {
     catch {
         // Docker not reachable — skip
     }
-    // 2. Remove dangling volumes (anonymous volumes from service containers)
+    // 3. Remove dangling volumes (anonymous volumes from service containers)
     try {
         execSync(`docker volume prune -f`, {
             stdio: ["pipe", "pipe", "pipe"],

package/dist/output/cleanup.js

@@ -18,6 +18,7 @@ export function copyWorkspace(repoRoot, dest) {
     const files = execSync("git ls-files --cached --others --exclude-standard -z", {
         stdio: "pipe",
         cwd: repoRoot,
+        maxBuffer: 100 * 1024 * 1024, // 100MB — default 1MB overflows in large monorepos
     })
         .toString()
         .split("\0")
@@ -82,6 +83,25 @@ const LOCKFILE_NAMES = [
     "bun.lock",
     "bun.lockb",
 ];
+const LOCKFILE_TO_PM = {
+    "pnpm-lock.yaml": "pnpm",
+    "package-lock.json": "npm",
+    "yarn.lock": "yarn",
+    "bun.lock": "bun",
+    "bun.lockb": "bun",
+};
+/**
+ * Detect the project's package manager by looking for lockfiles in the repo root.
+ * Returns the first match in priority order, or null if no lockfile is found.
+ */
+export function detectPackageManager(repoRoot) {
+    for (const name of LOCKFILE_NAMES) {
+        if (fs.existsSync(path.join(repoRoot, name))) {
+            return LOCKFILE_TO_PM[name];
+        }
+    }
+    return null;
+}
 /**
  * Compute a short SHA-256 hash of lockfiles tracked in the repo.
  * Searches for all known lockfile types (pnpm, npm, yarn, bun) and hashes

package/dist/output/cleanup.test.js

@@ -136,6 +136,51 @@ describe("computeLockfileHash", () => {
         expect(hash).toMatch(/^[a-f0-9]{16}$/);
     });
 });
+// ── detectPackageManager tests ────────────────────────────────────────────────
+describe("detectPackageManager", () => {
+    let repoDir;
+    beforeEach(() => {
+        repoDir = fs.mkdtempSync(path.join(os.tmpdir(), "oa-pm-detect-"));
+    });
+    afterEach(() => {
+        fs.rmSync(repoDir, { recursive: true, force: true });
+    });
+    it("detects pnpm from pnpm-lock.yaml", async () => {
+        const { detectPackageManager } = await import("./cleanup.js");
+        fs.writeFileSync(path.join(repoDir, "pnpm-lock.yaml"), "lockfileVersion: '9.0'\n");
+        expect(detectPackageManager(repoDir)).toBe("pnpm");
+    });
+    it("detects npm from package-lock.json", async () => {
+        const { detectPackageManager } = await import("./cleanup.js");
+        fs.writeFileSync(path.join(repoDir, "package-lock.json"), '{"lockfileVersion": 3}');
+        expect(detectPackageManager(repoDir)).toBe("npm");
+    });
+    it("detects yarn from yarn.lock", async () => {
+        const { detectPackageManager } = await import("./cleanup.js");
+        fs.writeFileSync(path.join(repoDir, "yarn.lock"), "# yarn lockfile v1");
+        expect(detectPackageManager(repoDir)).toBe("yarn");
+    });
+    it("detects bun from bun.lock", async () => {
+        const { detectPackageManager } = await import("./cleanup.js");
+        fs.writeFileSync(path.join(repoDir, "bun.lock"), '{"lockfileVersion": 0}');
+        expect(detectPackageManager(repoDir)).toBe("bun");
+    });
+    it("detects bun from bun.lockb", async () => {
+        const { detectPackageManager } = await import("./cleanup.js");
+        fs.writeFileSync(path.join(repoDir, "bun.lockb"), Buffer.from([0x00]));
+        expect(detectPackageManager(repoDir)).toBe("bun");
+    });
+    it("returns null when no lockfile exists", async () => {
+        const { detectPackageManager } = await import("./cleanup.js");
+        expect(detectPackageManager(repoDir)).toBeNull();
+    });
+    it("prefers pnpm over npm when both lockfiles exist", async () => {
+        const { detectPackageManager } = await import("./cleanup.js");
+        fs.writeFileSync(path.join(repoDir, "pnpm-lock.yaml"), "lockfileVersion: '9.0'\n");
+        fs.writeFileSync(path.join(repoDir, "package-lock.json"), '{"lockfileVersion": 3}');
+        expect(detectPackageManager(repoDir)).toBe("pnpm");
+    });
+});
 // ── isWarmNodeModules tests ───────────────────────────────────────────────────
 describe("isWarmNodeModules", () => {
     let tmpDir;

package/dist/output/logger.js

@@ -31,15 +31,44 @@ export function getNextLogNum(prefix) {
     });
     return nums.length > 0 ? Math.max(...nums) + 1 : 1;
 }
+/**
+ * Atomically allocate a numbered run directory under `runs/`.
+ * Uses mkdirSync without `recursive` so that EEXIST signals a
+ * collision — the caller just increments and retries.
+ */
+function allocateRunDir(prefix) {
+    const runsDir = getRunsDir();
+    let num = getNextLogNum(prefix);
+    for (;;) {
+        const name = `${prefix}-${num}`;
+        const runDir = path.join(runsDir, name);
+        try {
+            fs.mkdirSync(runDir); // atomic — fails with EEXIST on collision
+            return { num, name, runDir };
+        }
+        catch (err) {
+            if (err.code === "EEXIST") {
+                num++;
+                continue;
+            }
+            throw err;
+        }
+    }
+}
 export function createLogContext(prefix, preferredName) {
     ensureLogDirs();
-    let num = 0;
-    let name = preferredName;
-    if (!name) {
-        num = getNextLogNum(prefix);
-        name = `${prefix}-${num}`;
+    let num;
+    let name;
+    let runDir;
+    if (preferredName) {
+        num = 0;
+        name = preferredName;
+        runDir = path.join(getRunsDir(), name);
+        fs.mkdirSync(runDir, { recursive: true });
+    }
+    else {
+        ({ num, name, runDir } = allocateRunDir(prefix));
     }
-    const runDir = path.join(getRunsDir(), name);
     const logDir = path.join(runDir, "logs");
     fs.mkdirSync(logDir, { recursive: true });
     return {

package/dist/output/logger.test.js

@@ -78,5 +78,45 @@ describe("Logger utilities", () => {
             const second = createLogContext("agent-ci");
             expect(second.num).toBe(first.num + 1);
         });
+        it("skips over a directory that already exists (race condition)", async () => {
+            const { setWorkingDirectory } = await import("./working-directory.js");
+            const { createLogContext } = await import("./logger.js");
+            setWorkingDirectory(tmpDir);
+            // Pre-create runs/agent-ci-1 to simulate another process winning the race
+            fs.mkdirSync(path.join(tmpDir, "runs", "agent-ci-1"), { recursive: true });
+            const ctx = createLogContext("agent-ci");
+            // Should have skipped 1 and landed on 2
+            expect(ctx.num).toBe(2);
+            expect(ctx.name).toBe("agent-ci-2");
+            expect(fs.existsSync(ctx.runDir)).toBe(true);
+        });
+        it("handles multiple consecutive collisions", async () => {
+            const { setWorkingDirectory } = await import("./working-directory.js");
+            const { createLogContext } = await import("./logger.js");
+            setWorkingDirectory(tmpDir);
+            // Pre-create 1, 2, and 3 to simulate several concurrent processes
+            fs.mkdirSync(path.join(tmpDir, "runs", "agent-ci-1"), { recursive: true });
+            fs.mkdirSync(path.join(tmpDir, "runs", "agent-ci-2"), { recursive: true });
+            fs.mkdirSync(path.join(tmpDir, "runs", "agent-ci-3"), { recursive: true });
+            const ctx = createLogContext("agent-ci");
+            expect(ctx.num).toBe(4);
+            expect(ctx.name).toBe("agent-ci-4");
+            expect(fs.existsSync(ctx.runDir)).toBe(true);
+        });
+        it("concurrent calls each get a unique directory", async () => {
+            const { setWorkingDirectory } = await import("./working-directory.js");
+            const { createLogContext } = await import("./logger.js");
+            setWorkingDirectory(tmpDir);
+            // Call createLogContext many times synchronously — each should get a unique dir
+            const results = Array.from({ length: 10 }, () => createLogContext("agent-ci"));
+            const names = results.map((r) => r.name);
+            const uniqueNames = new Set(names);
+            expect(uniqueNames.size).toBe(10);
+            // All directories should exist
+            for (const r of results) {
+                expect(fs.existsSync(r.runDir)).toBe(true);
+                expect(fs.existsSync(r.logDir)).toBe(true);
+            }
+        });
     });
 });

package/dist/output/reporter.test.js

@@ -71,3 +71,39 @@ describe("printSummary", () => {
         expect(output).not.toContain("FAILURES");
     });
 });
+// ── Empty results behavior (CLI exit logic) ──────────────────────────────────
+// The CLI treats empty results as failure. These tests verify the logic pattern
+// used in cli.ts: `results.length === 0 || results.some(r => !r.succeeded)`
+describe("empty results exit logic", () => {
+    function shouldFail(results) {
+        return results.length === 0 || results.some((r) => !r.succeeded);
+    }
+    function shouldPrintSummary(results) {
+        return results.length > 0;
+    }
+    it("treats empty results as failure", () => {
+        expect(shouldFail([])).toBe(true);
+    });
+    it("treats results with a failure as failure", () => {
+        expect(shouldFail([makeResult({ succeeded: false })])).toBe(true);
+    });
+    it("treats all-passing results as success", () => {
+        const passing = [
+            {
+                name: "c1",
+                workflow: "ci.yml",
+                taskId: "test",
+                succeeded: true,
+                durationMs: 100,
+                debugLogPath: "/tmp/x",
+            },
+        ];
+        expect(shouldFail(passing)).toBe(false);
+    });
+    it("skips summary print for empty results", () => {
+        expect(shouldPrintSummary([])).toBe(false);
+    });
+    it("prints summary for non-empty results", () => {
+        expect(shouldPrintSummary([makeResult()])).toBe(true);
+    });
+});

package/dist/output/state-renderer.js

@@ -17,6 +17,18 @@ function getSpinnerFrame() {
 function fmtMs(ms) {
     return ms >= 1000 ? `${(ms / 1000).toFixed(1)}s` : `${ms}ms`;
 }
+function fmtBytes(bytes) {
+    if (bytes >= 1000000000) {
+        return `${(bytes / 1000000000).toFixed(1)} GB`;
+    }
+    if (bytes >= 1000000) {
+        return `${(bytes / 1000000).toFixed(1)} MB`;
+    }
+    if (bytes >= 1000) {
+        return `${(bytes / 1000).toFixed(1)} KB`;
+    }
+    return `${bytes} B`;
+}
 // ─── Step node builder ────────────────────────────────────────────────────────
 function buildStepNode(step, job, padW) {
     const pad = (n) => String(n).padStart(padW);
@@ -72,8 +84,21 @@ function buildJobNodes(job, singleJobMode) {
         const bootNode = {
             label: `${getSpinnerFrame()} Starting runner ${job.runnerId} (${elapsed}s)`,
         };
+        const children = [];
+        if (job.pullProgress) {
+            const { phase, currentBytes, totalBytes } = job.pullProgress;
+            const pct = totalBytes > 0 ? Math.round((currentBytes / totalBytes) * 100) : 0;
+            const label = phase === "extracting" ? "Extracting" : "Downloading";
+            children.push({
+                label: `${DIM}${label}: ${fmtBytes(currentBytes)} / ${fmtBytes(totalBytes)} (${pct}%)${RESET}`,
+            });
+        }
         if (job.logDir) {
-            bootNode.children = [{ label: `${DIM}Logs: ${job.logDir}${RESET}` }];
+            const shortLogDir = job.logDir.replace(/^.*?(agent-ci\/)/, "$1");
+            children.push({ label: `${DIM}Logs: ${shortLogDir}${RESET}` });
+        }
+        if (children.length > 0) {
+            bootNode.children = children;
         }
         return [bootNode];
     }