@redwoodjs/agent-ci 0.1.0 → 0.3.1

package/README.md

@@ -12,35 +12,34 @@ Agent CI runs on any machine that can run a container. When a step fails the run
 
 <!-- TODO: Add demo video/screen recording -->
 
-## Installation
-
-```bash
-npm install -g agent-ci
-```
-
-### Prerequisites
+## Prerequisites
 
 - **Docker** — A running Docker provider:
   - **macOS:** [OrbStack](https://orbstack.dev/) (recommended) or Docker Desktop
   - **Linux:** Native Docker Engine
 
-### Remote Docker
-
-Agent CI connects to Docker via the `DOCKER_HOST` environment variable. By default it uses the local socket (`unix:///var/run/docker.sock`), but you can point it at any remote Docker daemon:
+## Installation
 
 ```bash
-# Run containers on a remote machine via SSH
-DOCKER_HOST=ssh://user@remote-server agent-ci run --workflow .github/workflows/ci.yml
+npm install -D @redwoodjs/agent-ci
 ```
 
 ## Usage
 
 ```bash
 # Run a specific workflow
-agent-ci run --workflow .github/workflows/ci.yml
+npx agent-ci run --workflow .github/workflows/ci.yml
 
 # Run all relevant workflows for the current branch
-agent-ci run --all
+npx agent-ci run --all
+```
+
+### Remote Docker
+
+Agent CI connects to Docker via the `DOCKER_HOST` environment variable. By default it uses the local socket (`unix:///var/run/docker.sock`), but you can point it at any remote Docker daemon:
+
+```bash
+DOCKER_HOST=ssh://user@remote-server npx agent-ci run --workflow .github/workflows/ci.yml
 ```
 
 ### `agent-ci run`
@@ -77,3 +76,24 @@ Abort a paused runner and tear down its container.
 ## YAML Compatibility
 
 See [compatibility.md](./compatibility.md) for detailed GitHub Actions workflow syntax support.
+
+## Debugging
+
+Set the `DEBUG` environment variable to enable verbose debug logging. It accepts a comma-separated list of glob patterns matching the namespaces you want to see:
+
+| Value                             | What it shows                 |
+| --------------------------------- | ----------------------------- |
+| `DEBUG=agent-ci:*`                | All debug output              |
+| `DEBUG=agent-ci:cli`              | CLI-level logs only           |
+| `DEBUG=agent-ci:runner`           | Runner/container logs only    |
+| `DEBUG=agent-ci:dtu`              | DTU mock-server logs only     |
+| `DEBUG=agent-ci:boot`             | Boot/startup timing logs only |
+| `DEBUG=agent-ci:cli,agent-ci:dtu` | Multiple namespaces           |
+
+- Output goes to **stderr** so stdout stays clean for piping.
+- If `DEBUG` is unset or empty, all debug loggers become **no-ops** (zero overhead).
+- Pattern matching uses [minimatch](https://github.com/isaacs/minimatch) globs, so `agent-ci:*` matches all four namespaces.
+
+```bash
+DEBUG=agent-ci:* npx agent-ci run
+```

package/dist/cli.js

@@ -6,7 +6,8 @@ import { getNextLogNum } from "./output/logger.js";
 import { setWorkingDirectory, DEFAULT_WORKING_DIR, PROJECT_ROOT, } from "./output/working-directory.js";
 import { debugCli } from "./output/debug.js";
 import { executeLocalJob } from "./runner/local-job.js";
-import { getWorkflowTemplate, parseWorkflowSteps, parseWorkflowServices, parseWorkflowContainer, validateSecrets, parseMatrixDef, expandMatrixCombinations, isWorkflowRelevant, getChangedFiles, } from "./workflow/workflow-parser.js";
+import { getWorkflowTemplate, parseWorkflowSteps, parseWorkflowServices, parseWorkflowContainer, validateSecrets, parseMatrixDef, expandMatrixCombinations, isWorkflowRelevant, getChangedFiles, parseJobOutputDefs, parseJobIf, evaluateJobIf, parseFailFast, } from "./workflow/workflow-parser.js";
+import { resolveJobOutputs } from "./runner/result-builder.js";
 import { createConcurrencyLimiter, getDefaultMaxConcurrentJobs } from "./output/concurrency.js";
 import { isWarmNodeModules, computeLockfileHash } from "./output/cleanup.js";
 import { getWorkingDirectory } from "./output/working-directory.js";
@@ -18,7 +19,7 @@ import { RunStateStore } from "./output/run-state.js";
 import { renderRunState } from "./output/state-renderer.js";
 import { isAgentMode, setQuietMode } from "./output/agent-mode.js";
 import logUpdate from "log-update";
-// ─── Signal helpers for retry / abort commands ────────────────────────────────
+import { createFailedJobResult, wrapJobError, isJobError } from "./runner/job-result.js";
 function findSignalsDir(runnerName) {
     const workDir = getWorkingDirectory();
     const runsDir = path.resolve(workDir, "runs");
@@ -340,6 +341,9 @@ async function runWorkflows(options) {
                     if (s.status === "fulfilled") {
                         allResults.push(...s.value);
                     }
+                    else {
+                        console.error(`\n[Agent CI] Workflow failed: ${s.reason?.message || String(s.reason)}`);
+                    }
                 }
             }
             else {
@@ -348,6 +352,9 @@ async function runWorkflows(options) {
                     if (s.status === "fulfilled") {
                         allResults.push(...s.value);
                     }
+                    else {
+                        console.error(`\n[Agent CI] Workflow failed: ${s.reason?.message || String(s.reason)}`);
+                    }
                 }
             }
         }
@@ -497,24 +504,36 @@ async function handleWorkflow(options) {
                 taskId: ej.taskName,
             };
         };
-        const runJob = async (ej) => {
+        const runJob = async (ej, needsContext) => {
             const { taskName, matrixContext } = ej;
             debugCli(`Running: ${path.basename(workflowPath)} | Task: ${taskName}${matrixContext ? ` | Matrix: ${JSON.stringify(Object.fromEntries(Object.entries(matrixContext).filter(([k]) => !k.startsWith("__"))))}` : ""}`);
             const secrets = loadMachineSecrets(repoRoot);
             const secretsFilePath = path.join(repoRoot, ".env.agent-ci");
             validateSecrets(workflowPath, taskName, secrets, secretsFilePath);
-            const steps = await parseWorkflowSteps(workflowPath, taskName, secrets, matrixContext);
+            const steps = await parseWorkflowSteps(workflowPath, taskName, secrets, matrixContext, needsContext);
             const services = await parseWorkflowServices(workflowPath, taskName);
             const container = await parseWorkflowContainer(workflowPath, taskName);
             const job = buildJob(ej);
             job.steps = steps;
             job.services = services;
             job.container = container ?? undefined;
-            return executeLocalJob(job, { pauseOnFailure, store });
+            const result = await executeLocalJob(job, { pauseOnFailure, store });
+            // result.outputs now contains raw step outputs (extracted inside executeLocalJob
+            // before workspace cleanup). Resolve them to job-level outputs using the
+            // output definitions from the workflow YAML.
+            if (result.outputs && Object.keys(result.outputs).length > 0) {
+                const outputDefs = parseJobOutputDefs(workflowPath, taskName);
+                if (Object.keys(outputDefs).length > 0) {
+                    result.outputs = resolveJobOutputs(outputDefs, result.outputs);
+                }
+            }
+            return result;
         };
         pruneOrphanedDockerResources();
         const limiter = createConcurrencyLimiter(maxJobs);
         const allResults = [];
+        // Accumulate job outputs across waves for needs.*.outputs.* resolution
+        const jobOutputs = new Map();
         // ── Dependency-aware wave scheduling ──────────────────────────────────────
         const deps = parseJobDependencies(workflowPath);
         const waves = topoSort(deps);
@@ -525,6 +544,73 @@ async function handleWorkflow(options) {
         if (filteredWaves.length === 0) {
             filteredWaves.push(Array.from(taskNamesInWf));
         }
+        /** Build a needsContext for a job from its dependencies' accumulated outputs */
+        const buildNeedsContext = (jobId) => {
+            const jobDeps = deps.get(jobId);
+            if (!jobDeps || jobDeps.length === 0) {
+                return undefined;
+            }
+            const ctx = {};
+            for (const depId of jobDeps) {
+                ctx[depId] = jobOutputs.get(depId) ?? {};
+            }
+            return ctx;
+        };
+        /** Collect outputs from a completed job result */
+        const collectOutputs = (result, taskName) => {
+            if (result.outputs && Object.keys(result.outputs).length > 0) {
+                jobOutputs.set(taskName, result.outputs);
+            }
+        };
+        // Track job results for if-condition evaluation (success/failure status)
+        const jobResultStatus = new Map();
+        /** Check if a job should be skipped based on its if: condition */
+        const shouldSkipJob = (jobId) => {
+            const ifExpr = parseJobIf(workflowPath, jobId);
+            if (ifExpr === null) {
+                // No if: condition — default behavior is success() (skip if any upstream failed)
+                const jobDeps = deps.get(jobId);
+                if (jobDeps && jobDeps.length > 0) {
+                    const anyFailed = jobDeps.some((d) => jobResultStatus.get(d) === "failure");
+                    if (anyFailed) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+            // Build upstream job results for the evaluator
+            const upstreamResults = {};
+            const jobDeps = deps.get(jobId) ?? [];
+            for (const depId of jobDeps) {
+                upstreamResults[depId] = jobResultStatus.get(depId) ?? "success";
+            }
+            const needsCtx = buildNeedsContext(jobId);
+            return !evaluateJobIf(ifExpr, upstreamResults, needsCtx);
+        };
+        /** Create a synthetic skipped result for a job that was skipped by if: */
+        const skippedResult = (ej) => ({
+            name: `agent-ci-skipped-${ej.taskName}`,
+            workflow: path.basename(workflowPath),
+            taskId: ej.taskName,
+            succeeded: true,
+            durationMs: 0,
+            debugLogPath: "",
+            steps: [],
+        });
+        /** Run a job or skip it based on if: condition */
+        const runOrSkipJob = async (ej) => {
+            if (shouldSkipJob(ej.taskName)) {
+                debugCli(`Skipping ${ej.taskName} (if: condition is false)`);
+                const result = skippedResult(ej);
+                jobResultStatus.set(ej.taskName, "skipped");
+                return result;
+            }
+            const ctx = buildNeedsContext(ej.taskName);
+            const result = await runJob(ej, ctx);
+            jobResultStatus.set(ej.taskName, result.succeeded ? "success" : "failure");
+            collectOutputs(result, ej.taskName);
+            return result;
+        };
         for (let wi = 0; wi < filteredWaves.length; wi++) {
             const waveJobIds = new Set(filteredWaves[wi]);
             const waveJobs = expandedJobs.filter((j) => waveJobIds.has(j.taskName));
@@ -534,28 +620,56 @@ async function handleWorkflow(options) {
             // ── Warm-cache serialization for the first wave ────────────────────────
             if (!warm && wi === 0 && waveJobs.length > 1) {
                 debugCli("Cold cache — running first job to populate warm modules...");
-                const firstResult = await runJob(waveJobs[0]);
+                const firstResult = await runOrSkipJob(waveJobs[0]);
                 allResults.push(firstResult);
-                const results = await Promise.allSettled(waveJobs.slice(1).map((ej) => limiter.run(() => runJob(ej))));
+                const results = await Promise.allSettled(waveJobs.slice(1).map((ej) => limiter.run(() => runOrSkipJob(ej).catch((error) => {
+                    throw wrapJobError(ej.taskName, error);
+                }))));
                 for (const r of results) {
                     if (r.status === "fulfilled") {
                         allResults.push(r.value);
                     }
+                    else {
+                        const taskName = isJobError(r.reason) ? r.reason.taskName : "unknown";
+                        const errorMessage = isJobError(r.reason) ? r.reason.message : String(r.reason);
+                        console.error(`\n[Agent CI] Job failed with error: ${taskName}`);
+                        console.error(`  Error: ${errorMessage}`);
+                        allResults.push(createFailedJobResult(taskName, workflowPath, r.reason));
+                    }
                 }
                 warm = true;
             }
             else {
-                const results = await Promise.allSettled(waveJobs.map((ej) => limiter.run(() => runJob(ej))));
+                const results = await Promise.allSettled(waveJobs.map((ej) => limiter.run(() => runOrSkipJob(ej).catch((error) => {
+                    throw wrapJobError(ej.taskName, error);
+                }))));
                 for (const r of results) {
                     if (r.status === "fulfilled") {
                         allResults.push(r.value);
                     }
+                    else {
+                        const taskName = isJobError(r.reason) ? r.reason.taskName : "unknown";
+                        const errorMessage = isJobError(r.reason) ? r.reason.message : String(r.reason);
+                        console.error(`\n[Agent CI] Job failed with error: ${taskName}`);
+                        console.error(`  Error: ${errorMessage}`);
+                        allResults.push(createFailedJobResult(taskName, workflowPath, r.reason));
+                    }
                 }
             }
-            // Abort remaining waves if this wave had failures
-            if (allResults.some((r) => !r.succeeded) && wi < filteredWaves.length - 1) {
-                debugCli(`Wave ${wi + 1} had failures — aborting remaining waves for ${path.basename(workflowPath)}`);
-                break;
+            // Check whether to abort remaining waves on failure
+            const waveHadFailures = allResults.some((r) => !r.succeeded);
+            if (waveHadFailures && wi < filteredWaves.length - 1) {
+                // Check fail-fast setting for jobs in this wave
+                const waveFailFastSettings = waveJobs.map((ej) => parseFailFast(workflowPath, ej.taskName));
+                // Abort unless ALL jobs in the wave explicitly set fail-fast: false
+                const shouldAbort = !waveFailFastSettings.every((ff) => ff === false);
+                if (shouldAbort) {
+                    debugCli(`Wave ${wi + 1} had failures — aborting remaining waves for ${path.basename(workflowPath)}`);
+                    break;
+                }
+                else {
+                    debugCli(`Wave ${wi + 1} had failures but fail-fast is disabled — continuing`);
+                }
             }
         }
         return allResults;

package/dist/output/working-directory.js

@@ -2,7 +2,7 @@ import path from "node:path";
 import os from "node:os";
 import fs from "node:fs";
 import { fileURLToPath } from "node:url";
-// Pinned to the monorepo root (project root), not the cli package
+// Pinned to the cli package root
 export const PROJECT_ROOT = path.resolve(fileURLToPath(import.meta.url), "..", "..", "..");
 // When running inside a container with Docker-outside-of-Docker (shared socket),
 // /tmp is NOT visible to the Docker host. Use a project-relative directory

package/dist/runner/job-result.js

@@ -0,0 +1,37 @@
+import path from "path";
+export function isJobError(error) {
+    if (typeof error !== "object" || error === null) {
+        return false;
+    }
+    const err = error;
+    return typeof err.taskName === "string";
+}
+export function getErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === "string") {
+        return error;
+    }
+    return String(error);
+}
+export function createFailedJobResult(taskName, workflowPath, error) {
+    const errorMessage = isJobError(error) ? error.message : getErrorMessage(error);
+    return {
+        name: `agent-ci-error-${taskName}`,
+        workflow: path.basename(workflowPath),
+        taskId: taskName,
+        succeeded: false,
+        durationMs: 0,
+        debugLogPath: "",
+        failedStep: "[Job startup failed]",
+        lastOutputLines: [errorMessage],
+    };
+}
+export function wrapJobError(taskName, error) {
+    return {
+        taskName,
+        message: getErrorMessage(error),
+        originalError: error,
+    };
+}

package/dist/runner/job-result.test.js

@@ -0,0 +1,100 @@
+import { describe, it, expect } from "vitest";
+import { createFailedJobResult, wrapJobError, isJobError, getErrorMessage, } from "./job-result.js";
+describe("getErrorMessage", () => {
+    it("extracts message from Error object", () => {
+        const result = getErrorMessage(new Error("test message"));
+        expect(result).toBe("test message");
+    });
+    it("returns string as-is", () => {
+        const result = getErrorMessage("string error");
+        expect(result).toBe("string error");
+    });
+    it("converts other types to string", () => {
+        expect(getErrorMessage(123)).toBe("123");
+        expect(getErrorMessage(null)).toBe("null");
+        expect(getErrorMessage(undefined)).toBe("undefined");
+        expect(getErrorMessage({ code: "ENOENT" })).toBe("[object Object]");
+    });
+});
+describe("isJobError", () => {
+    it("returns true for valid JobError", () => {
+        const error = {
+            taskName: "test-job",
+            message: "something failed",
+            originalError: new Error("original"),
+        };
+        expect(isJobError(error)).toBe(true);
+    });
+    it("returns false for null", () => {
+        expect(isJobError(null)).toBe(false);
+    });
+    it("returns false for undefined", () => {
+        expect(isJobError(undefined)).toBe(false);
+    });
+    it("returns false for plain Error", () => {
+        expect(isJobError(new Error("test"))).toBe(false);
+    });
+    it("returns false for object without taskName", () => {
+        expect(isJobError({ message: "test" })).toBe(false);
+    });
+});
+describe("wrapJobError", () => {
+    it("wraps Error with taskName", () => {
+        const original = new Error("original error");
+        const wrapped = wrapJobError("my-job", original);
+        expect(wrapped.taskName).toBe("my-job");
+        expect(wrapped.message).toBe("original error");
+        expect(wrapped.originalError).toBe(original);
+    });
+    it("wraps string error with taskName", () => {
+        const wrapped = wrapJobError("my-job", "string error");
+        expect(wrapped.taskName).toBe("my-job");
+        expect(wrapped.message).toBe("string error");
+    });
+});
+describe("createFailedJobResult", () => {
+    it("creates a failed result with error message from Error object", () => {
+        const result = createFailedJobResult("setup_job", "/path/to/workflow.yml", new Error("Missing required secret: API_KEY"));
+        expect(result.succeeded).toBe(false);
+        expect(result.taskId).toBe("setup_job");
+        expect(result.workflow).toBe("workflow.yml");
+        expect(result.name).toBe("agent-ci-error-setup_job");
+        expect(result.failedStep).toBe("[Job startup failed]");
+        expect(result.durationMs).toBe(0);
+        expect(result.debugLogPath).toBe("");
+        expect(result.lastOutputLines).toEqual(["Missing required secret: API_KEY"]);
+    });
+    it("extracts message from JobError", () => {
+        const jobError = {
+            taskName: "wrapped-job",
+            message: "wrapped message",
+            originalError: new Error("original"),
+        };
+        const result = createFailedJobResult("test", "workflow.yml", jobError);
+        expect(result.lastOutputLines).toEqual(["wrapped message"]);
+    });
+    it("handles string errors", () => {
+        const result = createFailedJobResult("build_job", "/home/user/project/.github/workflows/ci.yaml", "Container failed to start");
+        expect(result.succeeded).toBe(false);
+        expect(result.taskId).toBe("build_job");
+        expect(result.workflow).toBe("ci.yaml");
+        expect(result.lastOutputLines).toEqual(["Container failed to start"]);
+    });
+    it("handles errors without message property", () => {
+        const result = createFailedJobResult("test_job", "workflow.yml", {
+            code: "ENOENT",
+            path: "/missing/file",
+        });
+        expect(result.succeeded).toBe(false);
+        expect(result.lastOutputLines).toEqual(["[object Object]"]);
+    });
+    it("handles null/undefined errors", () => {
+        const result = createFailedJobResult("job1", "workflow.yml", null);
+        expect(result.succeeded).toBe(false);
+        expect(result.lastOutputLines).toEqual(["null"]);
+    });
+    it("extracts basename from full workflow path", () => {
+        const result = createFailedJobResult("deploy", "/very/long/path/to/.github/workflows/production.yml", new Error("Deploy failed"));
+        expect(result.workflow).toBe("production.yml");
+    });
+});

package/dist/runner/local-job.js

@@ -17,7 +17,7 @@ import { prepareWorkspace } from "./workspace.js";
 import { createRunDirectories } from "./directory-setup.js";
 import { buildContainerEnv, buildContainerBinds, buildContainerCmd, resolveDtuHost, resolveDockerApiUrl, } from "../docker/container-config.js";
 import { buildJobResult, sanitizeStepName } from "./result-builder.js";
-import { wrapJobSteps } from "./step-wrapper.js";
+import { wrapJobSteps, appendOutputCaptureStep } from "./step-wrapper.js";
 import { syncWorkspaceForRetry } from "./sync.js";
 // ─── Docker setup ─────────────────────────────────────────────────────────────
 const dockerHost = process.env.DOCKER_HOST || "unix:///var/run/docker.sock";
@@ -169,7 +169,8 @@ export async function executeLocalJob(job, options) {
                 default_branch: job.repository?.default_branch || "main",
             }
             : job.repository;
-        const seededSteps = pauseOnFailure ? wrapJobSteps(job.steps ?? [], true) : job.steps;
+        const wrappedSteps = pauseOnFailure ? wrapJobSteps(job.steps ?? [], true) : job.steps;
+        const seededSteps = appendOutputCaptureStep(wrappedSteps ?? []);
         t0 = Date.now();
         const seedResponse = await fetch(`${dtuUrl}/_dtu/seed`, {
             method: "POST",
@@ -668,6 +669,19 @@ export async function executeLocalJob(job, options) {
         if (fs.existsSync(hostRunnerDir)) {
             fs.rmSync(hostRunnerDir, { recursive: true, force: true });
         }
+        // Read step outputs captured by the DTU server via the runner's outputs API
+        let stepOutputs = {};
+        if (jobSucceeded) {
+            const outputsFile = path.join(logDir, "outputs.json");
+            try {
+                if (fs.existsSync(outputsFile)) {
+                    stepOutputs = JSON.parse(fs.readFileSync(outputsFile, "utf-8"));
+                }
+            }
+            catch {
+                /* best-effort */
+            }
+        }
         if (jobSucceeded && fs.existsSync(dirs.containerWorkDir)) {
             fs.rmSync(dirs.containerWorkDir, { recursive: true, force: true });
         }
@@ -682,6 +696,7 @@ export async function executeLocalJob(job, options) {
             timelinePath,
             logDir,
             debugLogPath,
+            stepOutputs,
         });
     }
     finally {

package/dist/runner/result-builder.js

@@ -83,11 +83,117 @@ export function extractFailureDetails(timelinePath, failedStepName, logDir) {
     }
     return result;
 }
+// ─── Step output extraction ───────────────────────────────────────────────────
+/**
+ * Extract step outputs from the runner's `_runner_file_commands/` directory.
+ *
+ * The GitHub Actions runner writes step outputs to files named `set_output_<uuid>`
+ * in `<workDir>/_runner_file_commands/`. Each file contains key=value pairs,
+ * with multiline values using the heredoc format:
+ *   key<<DELIMITER
+ *   line1
+ *   line2
+ *   DELIMITER
+ *
+ * @param workDir The container's work directory (bind-mounted from host)
+ * @returns Record<string, string> of all output key-value pairs
+ */
+export function extractStepOutputs(workDir) {
+    const outputs = {};
+    // The runner writes to _temp/_runner_file_commands/ under the work dir
+    // $GITHUB_OUTPUT = /home/runner/_work/_temp/_runner_file_commands/set_output_<uuid>
+    const candidates = [
+        path.join(workDir, "_temp", "_runner_file_commands"),
+        path.join(workDir, "_runner_file_commands"),
+    ];
+    for (const fileCommandsDir of candidates) {
+        if (!fs.existsSync(fileCommandsDir)) {
+            continue;
+        }
+        let entries;
+        try {
+            entries = fs.readdirSync(fileCommandsDir).sort(); // Sort for deterministic override order
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (!entry.startsWith("set_output_")) {
+                continue;
+            }
+            try {
+                const content = fs.readFileSync(path.join(fileCommandsDir, entry), "utf-8");
+                parseOutputFileContent(content, outputs);
+            }
+            catch {
+                // Best-effort: skip unreadable files
+            }
+        }
+    }
+    return outputs;
+}
+/**
+ * Parse the content of a single set_output file into the outputs record.
+ * Handles both `key=value` and `key<<DELIMITER\nvalue\nDELIMITER` formats.
+ */
+function parseOutputFileContent(content, outputs) {
+    const lines = content.split("\n");
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        // Heredoc format: key<<DELIMITER
+        const heredocMatch = line.match(/^([^=]+)<<(.+)$/);
+        if (heredocMatch) {
+            const key = heredocMatch[1];
+            const delimiter = heredocMatch[2];
+            const valueLines = [];
+            i++;
+            while (i < lines.length && lines[i] !== delimiter) {
+                valueLines.push(lines[i]);
+                i++;
+            }
+            outputs[key] = valueLines.join("\n");
+            i++; // Skip the closing delimiter
+            continue;
+        }
+        // Simple format: key=value
+        const eqIdx = line.indexOf("=");
+        if (eqIdx > 0) {
+            const key = line.slice(0, eqIdx);
+            const value = line.slice(eqIdx + 1);
+            outputs[key] = value;
+        }
+        i++;
+    }
+}
+// ─── Job output resolution ────────────────────────────────────────────────────
+/**
+ * Resolve job output definitions against actual step outputs.
+ *
+ * Job output templates reference `steps.<stepId>.outputs.<name>`. Since the
+ * runner writes all step outputs to `$GITHUB_OUTPUT` files keyed only by
+ * output name (not step ID), we resolve by matching the output name from
+ * the template against the flat step outputs map.
+ *
+ * @param outputDefs  Job output definitions from parseJobOutputDefs
+ * @param stepOutputs Flat step outputs from extractStepOutputs
+ * @returns Resolved job outputs
+ */
+export function resolveJobOutputs(outputDefs, stepOutputs) {
+    const result = {};
+    for (const [outputName, template] of Object.entries(outputDefs)) {
+        // Replace ${{ steps.<id>.outputs.<name> }} with the actual step output value
+        result[outputName] = template.replace(/\$\{\{\s*steps\.[^.]+\.outputs\.([^\s}]+)\s*\}\}/g, (_match, outputKey) => {
+            return stepOutputs[outputKey] ?? "";
+        });
+    }
+    return result;
+}
 /**
  * Build the structured `JobResult` from container exit state and timeline data.
  */
 export function buildJobResult(opts) {
-    const { containerName, job, startTime, jobSucceeded, lastFailedStep, containerExitCode, timelinePath, logDir, debugLogPath, } = opts;
+    const { containerName, job, startTime, jobSucceeded, lastFailedStep, containerExitCode, timelinePath, logDir, debugLogPath, stepOutputs, } = opts;
     const steps = parseTimelineSteps(timelinePath);
     const result = {
         name: containerName,
@@ -115,5 +221,9 @@ export function buildJobResult(opts) {
             result.lastOutputLines = [];
         }
     }
+    // Attach raw step outputs (will be resolved to job outputs by cli.ts)
+    if (stepOutputs && Object.keys(stepOutputs).length > 0) {
+        result.outputs = stepOutputs;
+    }
     return result;
 }