@neriros/ralphy 2.7.7 → 2.7.9

package/README.md

@@ -113,6 +113,14 @@ Defaults are written to `ralphy.config.json` on first run; CLI flags override co
   "appendPrompt": "Always run lint before committing.",
   "createPrOnSuccess": true,
   "prBaseBranch": "main",
+  "fixCiOnFailure": true,
+  "maxCiFixAttempts": 5,
+  "ciPollIntervalSeconds": 30,
+  "maxRuntimeMinutesPerTask": 0,
+  "maxConsecutiveFailuresPerTask": 5,
+  "iterationDelaySeconds": 0,
+  "logRawStream": false,
+  "taskVerbose": false,
 }
 ```
 
@@ -130,6 +138,12 @@ Use `setupScript` (run inside the worktree right after scaffolding) to install d
 
 **`createPrOnSuccess`** (or `--create-pr`) pushes the worker's branch and opens a GitHub PR via `gh` after a clean exit. Requires `--worktree` (the PR needs a branch to point at) and the `gh` CLI authenticated. The PR title is `<ID>: <title>`, the body links the Linear issue. If a PR already exists for the branch the existing URL is reported (idempotent for retries). `prBaseBranch` defaults to `main`.
 
+**`fixCiOnFailure`** (or `--fix-ci`) watches the PR's checks via `gh pr checks` and, on failure, fetches the failed-run logs (`gh run view --log-failed`), appends them to `proposal.md` under `## Steering`, re-spawns the task loop in the worktree, and pushes the new commits — repeating until checks go green or `maxCiFixAttempts` is hit (default 5, polling interval `ciPollIntervalSeconds` defaults to 30s). Requires `--create-pr`.
+
+When `fixCiOnFailure` is enabled, the issue is **not** moved to `doneStatus` (and `doneLabel` is not applied, and the issue is not marked processed in `.ralph/agent-state.json`) until CI actually goes green. If the fix loop exhausts its attempts the worker is treated as failed for completion-marking purposes and the issue will be re-picked-up on the next poll (the resume-in-progress filter ensures that).
+
+Every CLI flag is also configurable in `ralphy.config.json`; CLI values override config when both are set. The agent forwards `maxRuntimeMinutesPerTask` / `maxConsecutiveFailuresPerTask` / `iterationDelaySeconds` / `logRawStream` / `taskVerbose` to each spawned `ralph task` worker.
+
 Failed workers (non-zero exit) are not marked processed, so they'll be retried on the next poll. SIGINT/SIGTERM cleanly stops polling and kills active workers. All Linear side effects are best-effort — failures log a warning but never block the task loop.
 
 ## CLI Options
@@ -153,19 +167,20 @@ Failed workers (non-zero exit) are not marked processed, so they'll be retried o
 
 ### Agent mode flags
 
-| Option                        | Description                                                           |
-| ----------------------------- | --------------------------------------------------------------------- |
-| `--linear-team <key>`         | Linear team key (e.g. `ENG`)                                          |
-| `--linear-assignee <id>`      | Filter by assignee (user id, email, or `me`)                          |
-| `--linear-status <name>`      | Filter by status name (repeatable)                                    |
-| `--linear-label <name>`       | Filter by label name (repeatable, any-of)                             |
-| `--poll-interval <s>`         | Seconds between Linear polls (default: 60)                            |
-| `--concurrency <n>`           | Max concurrent task loops (default: 1)                                |
-| `--worktree`                  | Run each task in its own git worktree                                 |
-| `--in-progress-status <name>` | Linear status to set when work starts                                 |
-| `--done-status <name>`        | Linear status to set on successful completion                         |
-| `--done-label <name>`         | Linear label to add on successful completion                          |
-| `--create-pr`                 | Push worker branch + open a GitHub PR on success (needs `--worktree`) |
+| Option                        | Description                                                                  |
+| ----------------------------- | ---------------------------------------------------------------------------- |
+| `--linear-team <key>`         | Linear team key (e.g. `ENG`)                                                 |
+| `--linear-assignee <id>`      | Filter by assignee (user id, email, or `me`)                                 |
+| `--linear-status <name>`      | Filter by status name (repeatable)                                           |
+| `--linear-label <name>`       | Filter by label name (repeatable, any-of)                                    |
+| `--poll-interval <s>`         | Seconds between Linear polls (default: 60)                                   |
+| `--concurrency <n>`           | Max concurrent task loops (default: 1)                                       |
+| `--worktree`                  | Run each task in its own git worktree                                        |
+| `--in-progress-status <name>` | Linear status to set when work starts                                        |
+| `--done-status <name>`        | Linear status to set on successful completion                                |
+| `--done-label <name>`         | Linear label to add on successful completion                                 |
+| `--create-pr`                 | Push worker branch + open a GitHub PR on success (needs `--worktree`)        |
+| `--fix-ci`                    | After PR opens, re-run task on CI failures until green (needs `--create-pr`) |
 
 ## OpenSpec Flow
 

package/dist/cli/index.js

@@ -56157,6 +56157,7 @@ var HELP_TEXT = [
   "  --done-status <name>    Linear status to set when work completes successfully",
   "  --done-label <name>     Linear label to add when work completes successfully",
   "  --create-pr             Push the worker branch and open a GitHub PR on success (needs --worktree)",
+  "  --fix-ci                After opening the PR, re-run the task on CI failures until green (needs --create-pr)",
   "",
   "  --help, -h              Show this help message",
   "",
@@ -56197,7 +56198,8 @@ async function parseArgs(argv) {
     inProgressStatus: "",
     doneStatus: "",
     doneLabel: "",
-    createPr: false
+    createPr: false,
+    fixCi: false
   };
   let expectModel = false;
   let expectModelFlag = false;
@@ -56421,6 +56423,9 @@ async function parseArgs(argv) {
       case "--create-pr":
         result2.createPr = true;
         break;
+      case "--fix-ci":
+        result2.fixCi = true;
+        break;
       default:
         if (VALID_MODES.has(arg)) {
           result2.mode = arg;
@@ -69845,6 +69850,11 @@ var RalphyConfigSchema = exports_external.object({
   pollIntervalSeconds: exports_external.number().int().positive().default(60),
   maxIterationsPerTask: exports_external.number().int().nonnegative().default(0),
   maxCostUsdPerTask: exports_external.number().nonnegative().default(0),
+  maxRuntimeMinutesPerTask: exports_external.number().nonnegative().default(0),
+  maxConsecutiveFailuresPerTask: exports_external.number().int().nonnegative().default(5),
+  iterationDelaySeconds: exports_external.number().int().nonnegative().default(0),
+  logRawStream: exports_external.boolean().default(false),
+  taskVerbose: exports_external.boolean().default(false),
   useWorktree: exports_external.boolean().default(false),
   cleanupWorktreeOnSuccess: exports_external.boolean().default(false),
   setupScript: exports_external.string().optional(),
@@ -69852,6 +69862,9 @@ var RalphyConfigSchema = exports_external.object({
   appendPrompt: exports_external.string().optional(),
   createPrOnSuccess: exports_external.boolean().default(false),
   prBaseBranch: exports_external.string().default("main"),
+  fixCiOnFailure: exports_external.boolean().default(false),
+  maxCiFixAttempts: exports_external.number().int().positive().default(5),
+  ciPollIntervalSeconds: exports_external.number().int().positive().default(30),
   engine: exports_external.enum(["claude", "codex"]).default("claude"),
   model: exports_external.enum(["haiku", "sonnet", "opus"]).default("opus"),
   linear: exports_external.object({
@@ -70187,6 +70200,80 @@ async function createPullRequest(input, runner) {
   return { url, created: true };
 }
 
+// apps/cli/src/agent/ci.ts
+var PR_CHECKS_FIELDS = "name,bucket,link,workflow,event";
+async function getPrChecksStatus(prRef, runner, cwd2) {
+  const out = await runner.run(["gh", "pr", "checks", prRef, "--json", PR_CHECKS_FIELDS], cwd2);
+  const checks = JSON.parse(out.stdout || "[]").filter((c) => c.bucket !== "skipping");
+  if (checks.some((c) => c.bucket === "pending")) {
+    return { bucket: "pending", failedRunIds: [] };
+  }
+  const failed = checks.filter((c) => c.bucket === "fail" || c.bucket === "cancel");
+  if (failed.length === 0)
+    return { bucket: "pass", failedRunIds: [] };
+  const ids = new Set;
+  for (const c of failed) {
+    const m = c.link?.match(/\/actions\/runs\/(\d+)/);
+    if (m)
+      ids.add(m[1]);
+  }
+  return { bucket: "fail", failedRunIds: [...ids] };
+}
+async function fetchFailedRunLogs(runIds, runner, cwd2, maxCharsPerRun = 4000) {
+  const chunks = [];
+  for (const id of runIds) {
+    try {
+      const r = await runner.run(["gh", "run", "view", id, "--log-failed"], cwd2);
+      const text = r.stdout.trim();
+      const truncated = text.length > maxCharsPerRun ? text.slice(0, maxCharsPerRun) + `
+\u2026[truncated ${text.length - maxCharsPerRun} chars]` : text;
+      chunks.push(`--- run ${id} ---
+${truncated}`);
+    } catch (err) {
+      chunks.push(`--- run ${id} ---
+(failed to fetch logs: ${err.message})`);
+    }
+  }
+  return chunks.join(`
+
+`);
+}
+async function fixCiUntilGreen(deps, opts) {
+  for (let attempt2 = 1;attempt2 <= opts.maxAttempts; attempt2++) {
+    while (true) {
+      if (deps.cancelled?.())
+        return { success: false, attempts: attempt2 - 1, reason: "cancelled" };
+      const s = await deps.getStatus();
+      if (s.bucket === "pass") {
+        deps.log(`\u2713 CI green for PR (after ${attempt2 - 1} fix attempts)`, "green");
+        return { success: true, attempts: attempt2 - 1 };
+      }
+      if (s.bucket === "fail") {
+        deps.log(`\u2717 CI failing (attempt ${attempt2}/${opts.maxAttempts}) \u2014 fetching logs and re-running task`, "yellow");
+        const logs = await deps.getFailedLogs(s.failedRunIds);
+        const steering = `CI is failing on this PR. Investigate and fix:
+
+\`\`\`
+${logs}
+\`\`\``;
+        const code = await deps.runTaskWithSteering(steering);
+        if (code !== 0) {
+          deps.log(`! task loop exited code ${code} during CI fix attempt ${attempt2}`, "red");
+        }
+        try {
+          await deps.pushBranch();
+        } catch (err) {
+          deps.log(`! push failed during CI fix: ${err.message}`, "red");
+          return { success: false, attempts: attempt2, reason: "push-failed" };
+        }
+        break;
+      }
+      await deps.sleep(opts.pollIntervalSeconds * 1000);
+    }
+  }
+  return { success: false, attempts: opts.maxAttempts, reason: "max-attempts" };
+}
+
 // apps/cli/src/components/AgentMode.tsx
 var jsx_dev_runtime9 = __toESM(require_jsx_dev_runtime(), 1);
 import { join as join14 } from "path";
@@ -70321,36 +70408,54 @@ function AgentMode({ args, projectRoot, statesDir, tasksDir }) {
           return changeName;
         },
         spawnWorker: (changeName) => {
-          const cmd = [
-            process.execPath,
-            process.argv[1] ?? "",
-            "task",
-            "--name",
-            changeName,
-            "--" + (args.engineSet ? args.engine : cfg.engine),
-            args.engineSet ? args.model : cfg.model
-          ];
-          const maxIter = args.maxIterations || cfg.maxIterationsPerTask;
-          if (maxIter > 0)
-            cmd.push("--max-iterations", String(maxIter));
-          const maxCost = args.maxCostUsd || cfg.maxCostUsdPerTask;
-          if (maxCost > 0)
-            cmd.push("--max-cost", String(maxCost));
+          const buildTaskCmd = () => {
+            const c = [
+              process.execPath,
+              process.argv[1] ?? "",
+              "task",
+              "--name",
+              changeName,
+              "--" + (args.engineSet ? args.engine : cfg.engine),
+              args.engineSet ? args.model : cfg.model
+            ];
+            const maxIter = args.maxIterations || cfg.maxIterationsPerTask;
+            if (maxIter > 0)
+              c.push("--max-iterations", String(maxIter));
+            const maxCost = args.maxCostUsd || cfg.maxCostUsdPerTask;
+            if (maxCost > 0)
+              c.push("--max-cost", String(maxCost));
+            const maxRuntime = args.maxRuntimeMinutes || cfg.maxRuntimeMinutesPerTask;
+            if (maxRuntime > 0)
+              c.push("--max-runtime", String(maxRuntime));
+            const maxFailures = args.maxConsecutiveFailures !== 5 ? args.maxConsecutiveFailures : cfg.maxConsecutiveFailuresPerTask;
+            if (maxFailures !== 5)
+              c.push("--max-failures", String(maxFailures));
+            const delay2 = args.delay || cfg.iterationDelaySeconds;
+            if (delay2 > 0)
+              c.push("--delay", String(delay2));
+            if (args.log || cfg.logRawStream)
+              c.push("--log");
+            if (args.verbose || cfg.taskVerbose)
+              c.push("--verbose");
+            return c;
+          };
           const cwd2 = cwdByChange.get(changeName) ?? projectRoot;
           const proc = Bun.spawn({
-            cmd,
+            cmd: buildTaskCmd(),
             cwd: cwd2,
             stdout: "ignore",
             stderr: "ignore",
             stdin: "ignore"
           });
           const wantPr = args.createPr || cfg.createPrOnSuccess;
+          const CI_FAILED_EXIT = 70;
           const wrapped = proc.exited.then(async (code) => {
             if (cfg.teardownScript) {
               try {
                 await runScript("teardown", cfg.teardownScript, cwd2);
               } catch {}
             }
+            let effectiveCode = code;
             const ok = code === 0;
             if (ok && wantPr) {
               const branch = branchByChange.get(changeName);
@@ -70364,6 +70469,56 @@ function AgentMode({ args, projectRoot, statesDir, tasksDir }) {
                     appendLog(`  no commits ahead of ${cfg.prBaseBranch} \u2014 skipping PR`, "gray");
                   } else {
                     appendLog(`  ${pr.created ? "opened" : "found existing"} PR: ${pr.url}`, "green");
+                    const wantFixCi = args.fixCi || cfg.fixCiOnFailure;
+                    if (wantFixCi) {
+                      appendLog(`  watching CI for ${pr.url} (max ${cfg.maxCiFixAttempts} fix attempts)`, "gray");
+                      const proposalPath = join14(statesDirByChange.get(changeName) ?? statesDir, "..", "..", "openspec", "changes", changeName, "proposal.md");
+                      const result2 = await fixCiUntilGreen({
+                        getStatus: () => getPrChecksStatus(pr.url, bunCmdRunner, cwd2),
+                        getFailedLogs: (ids) => fetchFailedRunLogs(ids, bunCmdRunner, cwd2),
+                        runTaskWithSteering: async (steering) => {
+                          try {
+                            const file = Bun.file(proposalPath);
+                            const prev = await file.exists() ? await file.text() : "";
+                            const stamped = `
+
+### CI feedback (${new Date().toISOString()})
+
+${steering}
+`;
+                            const next = prev.includes("## Steering") ? prev.replace(/## Steering\n+([\s\S]*?)$/, (_m, rest2) => `## Steering
+${stamped}
+${rest2}`) : prev + `
+## Steering
+${stamped}
+`;
+                            await Bun.write(proposalPath, next);
+                          } catch (err) {
+                            appendLog(`! could not append steering: ${err.message}`, "red");
+                          }
+                          const p = Bun.spawn({
+                            cmd: buildTaskCmd(),
+                            cwd: cwd2,
+                            stdout: "ignore",
+                            stderr: "ignore",
+                            stdin: "ignore"
+                          });
+                          return p.exited;
+                        },
+                        pushBranch: async () => {
+                          await bunCmdRunner.run(["git", "push", "origin", branch], cwd2);
+                        },
+                        log: appendLog,
+                        sleep: (ms) => new Promise((r) => setTimeout(r, ms))
+                      }, {
+                        maxAttempts: cfg.maxCiFixAttempts,
+                        pollIntervalSeconds: cfg.ciPollIntervalSeconds
+                      });
+                      if (!result2.success) {
+                        appendLog(`! CI fix loop gave up after ${result2.attempts} attempts (${result2.reason ?? "unknown"}) \u2014 withholding done-status until CI passes`, "red");
+                        effectiveCode = CI_FAILED_EXIT;
+                      }
+                    }
                   }
                 } catch (err) {
                   appendLog(`! PR create failed for ${changeName}: ${err.message}`, "red");
@@ -70371,7 +70526,7 @@ function AgentMode({ args, projectRoot, statesDir, tasksDir }) {
               }
             }
             if (useWorktree && cwd2 !== projectRoot) {
-              if (ok && cfg.cleanupWorktreeOnSuccess) {
+              if (effectiveCode === 0 && cfg.cleanupWorktreeOnSuccess) {
                 try {
                   await removeWorktree(projectRoot, cwd2, bunGitRunner);
                   appendLog(`  removed worktree ${cwd2}`, "gray");
@@ -70384,7 +70539,7 @@ function AgentMode({ args, projectRoot, statesDir, tasksDir }) {
             statesDirByChange.delete(changeName);
             branchByChange.delete(changeName);
             issueByChange.delete(changeName);
-            return code;
+            return effectiveCode;
           });
           return { exited: wrapped, kill: () => proc.kill() };
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neriros/ralphy",
-  "version": "2.7.7",
+  "version": "2.7.9",
   "description": "An iterative AI task execution framework. Orchestrates multi-phase autonomous work using Claude or Codex engines.",
   "keywords": [
     "agent",